From 8da9a14bdef28b90242a88875812dccdeb996b4f Mon Sep 17 00:00:00 2001 From: robertl Date: Tue, 5 Sep 2006 21:13:44 +0000 Subject: [PATCH] Add Expatw plus misc build tweaking to get an executable out of MSVC. git-svn-id: http://gpsbabel.googlecode.com/svn/trunk@2359 f51c46e8-681c-474f-0cfe-069cfd0219fb --- gpsbabel/msvc/Debug.empty | 0 gpsbabel/msvc/Expatw/expat.h | 1013 +++++++++++++++++++++++++ gpsbabel/msvc/Expatw/expat_external.h | 115 +++ gpsbabel/msvc/Expatw/libexpatw.dll | Bin 0 -> 151552 bytes gpsbabel/msvc/Expatw/libexpatw.lib | Bin 0 -> 17544 bytes gpsbabel/msvc/GPSBabel.sln | 4 +- gpsbabel/msvc/GPSBabel.vcproj | 14 +- gpsbabel/msvc/Unicode.empty | 0 gpsbabel/msvc/config.h | 2 +- gpsbabel/msvc/release.empty | 0 10 files changed, 1140 insertions(+), 8 deletions(-) create mode 100644 gpsbabel/msvc/Debug.empty create mode 100644 gpsbabel/msvc/Expatw/expat.h create mode 100644 gpsbabel/msvc/Expatw/expat_external.h create mode 100644 gpsbabel/msvc/Expatw/libexpatw.dll create mode 100644 gpsbabel/msvc/Expatw/libexpatw.lib create mode 100644 gpsbabel/msvc/Unicode.empty create mode 100644 gpsbabel/msvc/release.empty diff --git a/gpsbabel/msvc/Debug.empty b/gpsbabel/msvc/Debug.empty new file mode 100644 index 000000000..e69de29bb diff --git a/gpsbabel/msvc/Expatw/expat.h b/gpsbabel/msvc/Expatw/expat.h new file mode 100644 index 000000000..c6a4b3b6c --- /dev/null +++ b/gpsbabel/msvc/Expatw/expat.h @@ -0,0 +1,1013 @@ +/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd + See the file COPYING for copying permission. +*/ + +#ifndef Expat_INCLUDED +#define Expat_INCLUDED 1 + +#ifdef __VMS +/* 0 1 2 3 0 1 2 3 + 1234567890123456789012345678901 1234567890123456789012345678901 */ +#define XML_SetProcessingInstructionHandler XML_SetProcessingInstrHandler +#define XML_SetUnparsedEntityDeclHandler XML_SetUnparsedEntDeclHandler +#define XML_SetStartNamespaceDeclHandler XML_SetStartNamespcDeclHandler +#define XML_SetExternalEntityRefHandlerArg XML_SetExternalEntRefHandlerArg +#endif + +#include +#include "expat_external.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct XML_ParserStruct; +typedef struct XML_ParserStruct *XML_Parser; + +/* Should this be defined using stdbool.h when C99 is available? */ +typedef unsigned char XML_Bool; +#define XML_TRUE ((XML_Bool) 1) +#define XML_FALSE ((XML_Bool) 0) + +/* The XML_Status enum gives the possible return values for several + API functions. The preprocessor #defines are included so this + stanza can be added to code that still needs to support older + versions of Expat 1.95.x: + + #ifndef XML_STATUS_OK + #define XML_STATUS_OK 1 + #define XML_STATUS_ERROR 0 + #endif + + Otherwise, the #define hackery is quite ugly and would have been + dropped. +*/ +enum XML_Status { + XML_STATUS_ERROR = 0, +#define XML_STATUS_ERROR XML_STATUS_ERROR + XML_STATUS_OK = 1, +#define XML_STATUS_OK XML_STATUS_OK + XML_STATUS_SUSPENDED = 2 +#define XML_STATUS_SUSPENDED XML_STATUS_SUSPENDED +}; + +enum XML_Error { + XML_ERROR_NONE, + XML_ERROR_NO_MEMORY, + XML_ERROR_SYNTAX, + XML_ERROR_NO_ELEMENTS, + XML_ERROR_INVALID_TOKEN, + XML_ERROR_UNCLOSED_TOKEN, + XML_ERROR_PARTIAL_CHAR, + XML_ERROR_TAG_MISMATCH, + XML_ERROR_DUPLICATE_ATTRIBUTE, + XML_ERROR_JUNK_AFTER_DOC_ELEMENT, + XML_ERROR_PARAM_ENTITY_REF, + XML_ERROR_UNDEFINED_ENTITY, + XML_ERROR_RECURSIVE_ENTITY_REF, + XML_ERROR_ASYNC_ENTITY, + XML_ERROR_BAD_CHAR_REF, + XML_ERROR_BINARY_ENTITY_REF, + XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF, + XML_ERROR_MISPLACED_XML_PI, + XML_ERROR_UNKNOWN_ENCODING, + XML_ERROR_INCORRECT_ENCODING, + XML_ERROR_UNCLOSED_CDATA_SECTION, + XML_ERROR_EXTERNAL_ENTITY_HANDLING, + XML_ERROR_NOT_STANDALONE, + XML_ERROR_UNEXPECTED_STATE, + XML_ERROR_ENTITY_DECLARED_IN_PE, + XML_ERROR_FEATURE_REQUIRES_XML_DTD, + XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING, + /* Added in 1.95.7. */ + XML_ERROR_UNBOUND_PREFIX, + /* Added in 1.95.8. */ + XML_ERROR_UNDECLARING_PREFIX, + XML_ERROR_INCOMPLETE_PE, + XML_ERROR_XML_DECL, + XML_ERROR_TEXT_DECL, + XML_ERROR_PUBLICID, + XML_ERROR_SUSPENDED, + XML_ERROR_NOT_SUSPENDED, + XML_ERROR_ABORTED, + XML_ERROR_FINISHED, + XML_ERROR_SUSPEND_PE, + /* Added in 2.0. */ + XML_ERROR_RESERVED_PREFIX_XML, + XML_ERROR_RESERVED_PREFIX_XMLNS, + XML_ERROR_RESERVED_NAMESPACE_URI +}; + +enum XML_Content_Type { + XML_CTYPE_EMPTY = 1, + XML_CTYPE_ANY, + XML_CTYPE_MIXED, + XML_CTYPE_NAME, + XML_CTYPE_CHOICE, + XML_CTYPE_SEQ +}; + +enum XML_Content_Quant { + XML_CQUANT_NONE, + XML_CQUANT_OPT, + XML_CQUANT_REP, + XML_CQUANT_PLUS +}; + +/* If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be + XML_CQUANT_NONE, and the other fields will be zero or NULL. + If type == XML_CTYPE_MIXED, then quant will be NONE or REP and + numchildren will contain number of elements that may be mixed in + and children point to an array of XML_Content cells that will be + all of XML_CTYPE_NAME type with no quantification. + + If type == XML_CTYPE_NAME, then the name points to the name, and + the numchildren field will be zero and children will be NULL. The + quant fields indicates any quantifiers placed on the name. + + CHOICE and SEQ will have name NULL, the number of children in + numchildren and children will point, recursively, to an array + of XML_Content cells. + + The EMPTY, ANY, and MIXED types will only occur at top level. +*/ + +typedef struct XML_cp XML_Content; + +struct XML_cp { + enum XML_Content_Type type; + enum XML_Content_Quant quant; + XML_Char * name; + unsigned int numchildren; + XML_Content * children; +}; + + +/* This is called for an element declaration. See above for + description of the model argument. It's the caller's responsibility + to free model when finished with it. +*/ +typedef void (XMLCALL *XML_ElementDeclHandler) (void *userData, + const XML_Char *name, + XML_Content *model); + +XMLPARSEAPI(void) +XML_SetElementDeclHandler(XML_Parser parser, + XML_ElementDeclHandler eldecl); + +/* The Attlist declaration handler is called for *each* attribute. So + a single Attlist declaration with multiple attributes declared will + generate multiple calls to this handler. The "default" parameter + may be NULL in the case of the "#IMPLIED" or "#REQUIRED" + keyword. The "isrequired" parameter will be true and the default + value will be NULL in the case of "#REQUIRED". If "isrequired" is + true and default is non-NULL, then this is a "#FIXED" default. +*/ +typedef void (XMLCALL *XML_AttlistDeclHandler) ( + void *userData, + const XML_Char *elname, + const XML_Char *attname, + const XML_Char *att_type, + const XML_Char *dflt, + int isrequired); + +XMLPARSEAPI(void) +XML_SetAttlistDeclHandler(XML_Parser parser, + XML_AttlistDeclHandler attdecl); + +/* The XML declaration handler is called for *both* XML declarations + and text declarations. The way to distinguish is that the version + parameter will be NULL for text declarations. The encoding + parameter may be NULL for XML declarations. The standalone + parameter will be -1, 0, or 1 indicating respectively that there + was no standalone parameter in the declaration, that it was given + as no, or that it was given as yes. +*/ +typedef void (XMLCALL *XML_XmlDeclHandler) (void *userData, + const XML_Char *version, + const XML_Char *encoding, + int standalone); + +XMLPARSEAPI(void) +XML_SetXmlDeclHandler(XML_Parser parser, + XML_XmlDeclHandler xmldecl); + + +typedef struct { + void *(*malloc_fcn)(size_t size); + void *(*realloc_fcn)(void *ptr, size_t size); + void (*free_fcn)(void *ptr); +} XML_Memory_Handling_Suite; + +/* Constructs a new parser; encoding is the encoding specified by the + external protocol or NULL if there is none specified. +*/ +XMLPARSEAPI(XML_Parser) +XML_ParserCreate(const XML_Char *encoding); + +/* Constructs a new parser and namespace processor. Element type + names and attribute names that belong to a namespace will be + expanded; unprefixed attribute names are never expanded; unprefixed + element type names are expanded only if there is a default + namespace. The expanded name is the concatenation of the namespace + URI, the namespace separator character, and the local part of the + name. If the namespace separator is '\0' then the namespace URI + and the local part will be concatenated without any separator. + It is a programming error to use the separator '\0' with namespace + triplets (see XML_SetReturnNSTriplet). +*/ +XMLPARSEAPI(XML_Parser) +XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator); + + +/* Constructs a new parser using the memory management suite referred to + by memsuite. If memsuite is NULL, then use the standard library memory + suite. If namespaceSeparator is non-NULL it creates a parser with + namespace processing as described above. The character pointed at + will serve as the namespace separator. + + All further memory operations used for the created parser will come from + the given suite. +*/ +XMLPARSEAPI(XML_Parser) +XML_ParserCreate_MM(const XML_Char *encoding, + const XML_Memory_Handling_Suite *memsuite, + const XML_Char *namespaceSeparator); + +/* Prepare a parser object to be re-used. This is particularly + valuable when memory allocation overhead is disproportionatly high, + such as when a large number of small documnents need to be parsed. + All handlers are cleared from the parser, except for the + unknownEncodingHandler. The parser's external state is re-initialized + except for the values of ns and ns_triplets. + + Added in Expat 1.95.3. +*/ +XMLPARSEAPI(XML_Bool) +XML_ParserReset(XML_Parser parser, const XML_Char *encoding); + +/* atts is array of name/value pairs, terminated by 0; + names and values are 0 terminated. +*/ +typedef void (XMLCALL *XML_StartElementHandler) (void *userData, + const XML_Char *name, + const XML_Char **atts); + +typedef void (XMLCALL *XML_EndElementHandler) (void *userData, + const XML_Char *name); + + +/* s is not 0 terminated. */ +typedef void (XMLCALL *XML_CharacterDataHandler) (void *userData, + const XML_Char *s, + int len); + +/* target and data are 0 terminated */ +typedef void (XMLCALL *XML_ProcessingInstructionHandler) ( + void *userData, + const XML_Char *target, + const XML_Char *data); + +/* data is 0 terminated */ +typedef void (XMLCALL *XML_CommentHandler) (void *userData, + const XML_Char *data); + +typedef void (XMLCALL *XML_StartCdataSectionHandler) (void *userData); +typedef void (XMLCALL *XML_EndCdataSectionHandler) (void *userData); + +/* This is called for any characters in the XML document for which + there is no applicable handler. This includes both characters that + are part of markup which is of a kind that is not reported + (comments, markup declarations), or characters that are part of a + construct which could be reported but for which no handler has been + supplied. The characters are passed exactly as they were in the XML + document except that they will be encoded in UTF-8 or UTF-16. + Line boundaries are not normalized. Note that a byte order mark + character is not passed to the default handler. There are no + guarantees about how characters are divided between calls to the + default handler: for example, a comment might be split between + multiple calls. +*/ +typedef void (XMLCALL *XML_DefaultHandler) (void *userData, + const XML_Char *s, + int len); + +/* This is called for the start of the DOCTYPE declaration, before + any DTD or internal subset is parsed. +*/ +typedef void (XMLCALL *XML_StartDoctypeDeclHandler) ( + void *userData, + const XML_Char *doctypeName, + const XML_Char *sysid, + const XML_Char *pubid, + int has_internal_subset); + +/* This is called for the start of the DOCTYPE declaration when the + closing > is encountered, but after processing any external + subset. +*/ +typedef void (XMLCALL *XML_EndDoctypeDeclHandler)(void *userData); + +/* This is called for entity declarations. The is_parameter_entity + argument will be non-zero if the entity is a parameter entity, zero + otherwise. + + For internal entities (), value will + be non-NULL and systemId, publicID, and notationName will be NULL. + The value string is NOT nul-terminated; the length is provided in + the value_length argument. Since it is legal to have zero-length + values, do not use this argument to test for internal entities. + + For external entities, value will be NULL and systemId will be + non-NULL. The publicId argument will be NULL unless a public + identifier was provided. The notationName argument will have a + non-NULL value only for unparsed entity declarations. + + Note that is_parameter_entity can't be changed to XML_Bool, since + that would break binary compatibility. +*/ +typedef void (XMLCALL *XML_EntityDeclHandler) ( + void *userData, + const XML_Char *entityName, + int is_parameter_entity, + const XML_Char *value, + int value_length, + const XML_Char *base, + const XML_Char *systemId, + const XML_Char *publicId, + const XML_Char *notationName); + +XMLPARSEAPI(void) +XML_SetEntityDeclHandler(XML_Parser parser, + XML_EntityDeclHandler handler); + +/* OBSOLETE -- OBSOLETE -- OBSOLETE + This handler has been superceded by the EntityDeclHandler above. + It is provided here for backward compatibility. + + This is called for a declaration of an unparsed (NDATA) entity. + The base argument is whatever was set by XML_SetBase. The + entityName, systemId and notationName arguments will never be + NULL. The other arguments may be. +*/ +typedef void (XMLCALL *XML_UnparsedEntityDeclHandler) ( + void *userData, + const XML_Char *entityName, + const XML_Char *base, + const XML_Char *systemId, + const XML_Char *publicId, + const XML_Char *notationName); + +/* This is called for a declaration of notation. The base argument is + whatever was set by XML_SetBase. The notationName will never be + NULL. The other arguments can be. +*/ +typedef void (XMLCALL *XML_NotationDeclHandler) ( + void *userData, + const XML_Char *notationName, + const XML_Char *base, + const XML_Char *systemId, + const XML_Char *publicId); + +/* When namespace processing is enabled, these are called once for + each namespace declaration. The call to the start and end element + handlers occur between the calls to the start and end namespace + declaration handlers. For an xmlns attribute, prefix will be + NULL. For an xmlns="" attribute, uri will be NULL. +*/ +typedef void (XMLCALL *XML_StartNamespaceDeclHandler) ( + void *userData, + const XML_Char *prefix, + const XML_Char *uri); + +typedef void (XMLCALL *XML_EndNamespaceDeclHandler) ( + void *userData, + const XML_Char *prefix); + +/* This is called if the document is not standalone, that is, it has an + external subset or a reference to a parameter entity, but does not + have standalone="yes". If this handler returns XML_STATUS_ERROR, + then processing will not continue, and the parser will return a + XML_ERROR_NOT_STANDALONE error. + If parameter entity parsing is enabled, then in addition to the + conditions above this handler will only be called if the referenced + entity was actually read. +*/ +typedef int (XMLCALL *XML_NotStandaloneHandler) (void *userData); + +/* This is called for a reference to an external parsed general + entity. The referenced entity is not automatically parsed. The + application can parse it immediately or later using + XML_ExternalEntityParserCreate. + + The parser argument is the parser parsing the entity containing the + reference; it can be passed as the parser argument to + XML_ExternalEntityParserCreate. The systemId argument is the + system identifier as specified in the entity declaration; it will + not be NULL. + + The base argument is the system identifier that should be used as + the base for resolving systemId if systemId was relative; this is + set by XML_SetBase; it may be NULL. + + The publicId argument is the public identifier as specified in the + entity declaration, or NULL if none was specified; the whitespace + in the public identifier will have been normalized as required by + the XML spec. + + The context argument specifies the parsing context in the format + expected by the context argument to XML_ExternalEntityParserCreate; + context is valid only until the handler returns, so if the + referenced entity is to be parsed later, it must be copied. + context is NULL only when the entity is a parameter entity. + + The handler should return XML_STATUS_ERROR if processing should not + continue because of a fatal error in the handling of the external + entity. In this case the calling parser will return an + XML_ERROR_EXTERNAL_ENTITY_HANDLING error. + + Note that unlike other handlers the first argument is the parser, + not userData. +*/ +typedef int (XMLCALL *XML_ExternalEntityRefHandler) ( + XML_Parser parser, + const XML_Char *context, + const XML_Char *base, + const XML_Char *systemId, + const XML_Char *publicId); + +/* This is called in two situations: + 1) An entity reference is encountered for which no declaration + has been read *and* this is not an error. + 2) An internal entity reference is read, but not expanded, because + XML_SetDefaultHandler has been called. + Note: skipped parameter entities in declarations and skipped general + entities in attribute values cannot be reported, because + the event would be out of sync with the reporting of the + declarations or attribute values +*/ +typedef void (XMLCALL *XML_SkippedEntityHandler) ( + void *userData, + const XML_Char *entityName, + int is_parameter_entity); + +/* This structure is filled in by the XML_UnknownEncodingHandler to + provide information to the parser about encodings that are unknown + to the parser. + + The map[b] member gives information about byte sequences whose + first byte is b. + + If map[b] is c where c is >= 0, then b by itself encodes the + Unicode scalar value c. + + If map[b] is -1, then the byte sequence is malformed. + + If map[b] is -n, where n >= 2, then b is the first byte of an + n-byte sequence that encodes a single Unicode scalar value. + + The data member will be passed as the first argument to the convert + function. + + The convert function is used to convert multibyte sequences; s will + point to a n-byte sequence where map[(unsigned char)*s] == -n. The + convert function must return the Unicode scalar value represented + by this byte sequence or -1 if the byte sequence is malformed. + + The convert function may be NULL if the encoding is a single-byte + encoding, that is if map[b] >= -1 for all bytes b. + + When the parser is finished with the encoding, then if release is + not NULL, it will call release passing it the data member; once + release has been called, the convert function will not be called + again. + + Expat places certain restrictions on the encodings that are supported + using this mechanism. + + 1. Every ASCII character that can appear in a well-formed XML document, + other than the characters + + $@\^`{}~ + + must be represented by a single byte, and that byte must be the + same byte that represents that character in ASCII. + + 2. No character may require more than 4 bytes to encode. + + 3. All characters encoded must have Unicode scalar values <= + 0xFFFF, (i.e., characters that would be encoded by surrogates in + UTF-16 are not allowed). Note that this restriction doesn't + apply to the built-in support for UTF-8 and UTF-16. + + 4. No Unicode character may be encoded by more than one distinct + sequence of bytes. +*/ +typedef struct { + int map[256]; + void *data; + int (XMLCALL *convert)(void *data, const char *s); + void (XMLCALL *release)(void *data); +} XML_Encoding; + +/* This is called for an encoding that is unknown to the parser. + + The encodingHandlerData argument is that which was passed as the + second argument to XML_SetUnknownEncodingHandler. + + The name argument gives the name of the encoding as specified in + the encoding declaration. + + If the callback can provide information about the encoding, it must + fill in the XML_Encoding structure, and return XML_STATUS_OK. + Otherwise it must return XML_STATUS_ERROR. + + If info does not describe a suitable encoding, then the parser will + return an XML_UNKNOWN_ENCODING error. +*/ +typedef int (XMLCALL *XML_UnknownEncodingHandler) ( + void *encodingHandlerData, + const XML_Char *name, + XML_Encoding *info); + +XMLPARSEAPI(void) +XML_SetElementHandler(XML_Parser parser, + XML_StartElementHandler start, + XML_EndElementHandler end); + +XMLPARSEAPI(void) +XML_SetStartElementHandler(XML_Parser parser, + XML_StartElementHandler handler); + +XMLPARSEAPI(void) +XML_SetEndElementHandler(XML_Parser parser, + XML_EndElementHandler handler); + +XMLPARSEAPI(void) +XML_SetCharacterDataHandler(XML_Parser parser, + XML_CharacterDataHandler handler); + +XMLPARSEAPI(void) +XML_SetProcessingInstructionHandler(XML_Parser parser, + XML_ProcessingInstructionHandler handler); +XMLPARSEAPI(void) +XML_SetCommentHandler(XML_Parser parser, + XML_CommentHandler handler); + +XMLPARSEAPI(void) +XML_SetCdataSectionHandler(XML_Parser parser, + XML_StartCdataSectionHandler start, + XML_EndCdataSectionHandler end); + +XMLPARSEAPI(void) +XML_SetStartCdataSectionHandler(XML_Parser parser, + XML_StartCdataSectionHandler start); + +XMLPARSEAPI(void) +XML_SetEndCdataSectionHandler(XML_Parser parser, + XML_EndCdataSectionHandler end); + +/* This sets the default handler and also inhibits expansion of + internal entities. These entity references will be passed to the + default handler, or to the skipped entity handler, if one is set. +*/ +XMLPARSEAPI(void) +XML_SetDefaultHandler(XML_Parser parser, + XML_DefaultHandler handler); + +/* This sets the default handler but does not inhibit expansion of + internal entities. The entity reference will not be passed to the + default handler. +*/ +XMLPARSEAPI(void) +XML_SetDefaultHandlerExpand(XML_Parser parser, + XML_DefaultHandler handler); + +XMLPARSEAPI(void) +XML_SetDoctypeDeclHandler(XML_Parser parser, + XML_StartDoctypeDeclHandler start, + XML_EndDoctypeDeclHandler end); + +XMLPARSEAPI(void) +XML_SetStartDoctypeDeclHandler(XML_Parser parser, + XML_StartDoctypeDeclHandler start); + +XMLPARSEAPI(void) +XML_SetEndDoctypeDeclHandler(XML_Parser parser, + XML_EndDoctypeDeclHandler end); + +XMLPARSEAPI(void) +XML_SetUnparsedEntityDeclHandler(XML_Parser parser, + XML_UnparsedEntityDeclHandler handler); + +XMLPARSEAPI(void) +XML_SetNotationDeclHandler(XML_Parser parser, + XML_NotationDeclHandler handler); + +XMLPARSEAPI(void) +XML_SetNamespaceDeclHandler(XML_Parser parser, + XML_StartNamespaceDeclHandler start, + XML_EndNamespaceDeclHandler end); + +XMLPARSEAPI(void) +XML_SetStartNamespaceDeclHandler(XML_Parser parser, + XML_StartNamespaceDeclHandler start); + +XMLPARSEAPI(void) +XML_SetEndNamespaceDeclHandler(XML_Parser parser, + XML_EndNamespaceDeclHandler end); + +XMLPARSEAPI(void) +XML_SetNotStandaloneHandler(XML_Parser parser, + XML_NotStandaloneHandler handler); + +XMLPARSEAPI(void) +XML_SetExternalEntityRefHandler(XML_Parser parser, + XML_ExternalEntityRefHandler handler); + +/* If a non-NULL value for arg is specified here, then it will be + passed as the first argument to the external entity ref handler + instead of the parser object. +*/ +XMLPARSEAPI(void) +XML_SetExternalEntityRefHandlerArg(XML_Parser parser, + void *arg); + +XMLPARSEAPI(void) +XML_SetSkippedEntityHandler(XML_Parser parser, + XML_SkippedEntityHandler handler); + +XMLPARSEAPI(void) +XML_SetUnknownEncodingHandler(XML_Parser parser, + XML_UnknownEncodingHandler handler, + void *encodingHandlerData); + +/* This can be called within a handler for a start element, end + element, processing instruction or character data. It causes the + corresponding markup to be passed to the default handler. +*/ +XMLPARSEAPI(void) +XML_DefaultCurrent(XML_Parser parser); + +/* If do_nst is non-zero, and namespace processing is in effect, and + a name has a prefix (i.e. an explicit namespace qualifier) then + that name is returned as a triplet in a single string separated by + the separator character specified when the parser was created: URI + + sep + local_name + sep + prefix. + + If do_nst is zero, then namespace information is returned in the + default manner (URI + sep + local_name) whether or not the name + has a prefix. + + Note: Calling XML_SetReturnNSTriplet after XML_Parse or + XML_ParseBuffer has no effect. +*/ + +XMLPARSEAPI(void) +XML_SetReturnNSTriplet(XML_Parser parser, int do_nst); + +/* This value is passed as the userData argument to callbacks. */ +XMLPARSEAPI(void) +XML_SetUserData(XML_Parser parser, void *userData); + +/* Returns the last value set by XML_SetUserData or NULL. */ +#define XML_GetUserData(parser) (*(void **)(parser)) + +/* This is equivalent to supplying an encoding argument to + XML_ParserCreate. On success XML_SetEncoding returns non-zero, + zero otherwise. + Note: Calling XML_SetEncoding after XML_Parse or XML_ParseBuffer + has no effect and returns XML_STATUS_ERROR. +*/ +XMLPARSEAPI(enum XML_Status) +XML_SetEncoding(XML_Parser parser, const XML_Char *encoding); + +/* If this function is called, then the parser will be passed as the + first argument to callbacks instead of userData. The userData will + still be accessible using XML_GetUserData. +*/ +XMLPARSEAPI(void) +XML_UseParserAsHandlerArg(XML_Parser parser); + +/* If useDTD == XML_TRUE is passed to this function, then the parser + will assume that there is an external subset, even if none is + specified in the document. In such a case the parser will call the + externalEntityRefHandler with a value of NULL for the systemId + argument (the publicId and context arguments will be NULL as well). + Note: For the purpose of checking WFC: Entity Declared, passing + useDTD == XML_TRUE will make the parser behave as if the document + had a DTD with an external subset. + Note: If this function is called, then this must be done before + the first call to XML_Parse or XML_ParseBuffer, since it will + have no effect after that. Returns + XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING. + Note: If the document does not have a DOCTYPE declaration at all, + then startDoctypeDeclHandler and endDoctypeDeclHandler will not + be called, despite an external subset being parsed. + Note: If XML_DTD is not defined when Expat is compiled, returns + XML_ERROR_FEATURE_REQUIRES_XML_DTD. +*/ +XMLPARSEAPI(enum XML_Error) +XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD); + + +/* Sets the base to be used for resolving relative URIs in system + identifiers in declarations. Resolving relative identifiers is + left to the application: this value will be passed through as the + base argument to the XML_ExternalEntityRefHandler, + XML_NotationDeclHandler and XML_UnparsedEntityDeclHandler. The base + argument will be copied. Returns XML_STATUS_ERROR if out of memory, + XML_STATUS_OK otherwise. +*/ +XMLPARSEAPI(enum XML_Status) +XML_SetBase(XML_Parser parser, const XML_Char *base); + +XMLPARSEAPI(const XML_Char *) +XML_GetBase(XML_Parser parser); + +/* Returns the number of the attribute/value pairs passed in last call + to the XML_StartElementHandler that were specified in the start-tag + rather than defaulted. Each attribute/value pair counts as 2; thus + this correspondds to an index into the atts array passed to the + XML_StartElementHandler. +*/ +XMLPARSEAPI(int) +XML_GetSpecifiedAttributeCount(XML_Parser parser); + +/* Returns the index of the ID attribute passed in the last call to + XML_StartElementHandler, or -1 if there is no ID attribute. Each + attribute/value pair counts as 2; thus this correspondds to an + index into the atts array passed to the XML_StartElementHandler. +*/ +XMLPARSEAPI(int) +XML_GetIdAttributeIndex(XML_Parser parser); + +/* Parses some input. Returns XML_STATUS_ERROR if a fatal error is + detected. The last call to XML_Parse must have isFinal true; len + may be zero for this call (or any other). + + Though the return values for these functions has always been + described as a Boolean value, the implementation, at least for the + 1.95.x series, has always returned exactly one of the XML_Status + values. +*/ +XMLPARSEAPI(enum XML_Status) +XML_Parse(XML_Parser parser, const char *s, int len, int isFinal); + +XMLPARSEAPI(void *) +XML_GetBuffer(XML_Parser parser, int len); + +XMLPARSEAPI(enum XML_Status) +XML_ParseBuffer(XML_Parser parser, int len, int isFinal); + +/* Stops parsing, causing XML_Parse() or XML_ParseBuffer() to return. + Must be called from within a call-back handler, except when aborting + (resumable = 0) an already suspended parser. Some call-backs may + still follow because they would otherwise get lost. Examples: + - endElementHandler() for empty elements when stopped in + startElementHandler(), + - endNameSpaceDeclHandler() when stopped in endElementHandler(), + and possibly others. + + Can be called from most handlers, including DTD related call-backs, + except when parsing an external parameter entity and resumable != 0. + Returns XML_STATUS_OK when successful, XML_STATUS_ERROR otherwise. + Possible error codes: + - XML_ERROR_SUSPENDED: when suspending an already suspended parser. + - XML_ERROR_FINISHED: when the parser has already finished. + - XML_ERROR_SUSPEND_PE: when suspending while parsing an external PE. + + When resumable != 0 (true) then parsing is suspended, that is, + XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED. + Otherwise, parsing is aborted, that is, XML_Parse() and XML_ParseBuffer() + return XML_STATUS_ERROR with error code XML_ERROR_ABORTED. + + *Note*: + This will be applied to the current parser instance only, that is, if + there is a parent parser then it will continue parsing when the + externalEntityRefHandler() returns. It is up to the implementation of + the externalEntityRefHandler() to call XML_StopParser() on the parent + parser (recursively), if one wants to stop parsing altogether. + + When suspended, parsing can be resumed by calling XML_ResumeParser(). +*/ +XMLPARSEAPI(enum XML_Status) +XML_StopParser(XML_Parser parser, XML_Bool resumable); + +/* Resumes parsing after it has been suspended with XML_StopParser(). + Must not be called from within a handler call-back. Returns same + status codes as XML_Parse() or XML_ParseBuffer(). + Additional error code XML_ERROR_NOT_SUSPENDED possible. + + *Note*: + This must be called on the most deeply nested child parser instance + first, and on its parent parser only after the child parser has finished, + to be applied recursively until the document entity's parser is restarted. + That is, the parent parser will not resume by itself and it is up to the + application to call XML_ResumeParser() on it at the appropriate moment. +*/ +XMLPARSEAPI(enum XML_Status) +XML_ResumeParser(XML_Parser parser); + +enum XML_Parsing { + XML_INITIALIZED, + XML_PARSING, + XML_FINISHED, + XML_SUSPENDED +}; + +typedef struct { + enum XML_Parsing parsing; + XML_Bool finalBuffer; +} XML_ParsingStatus; + +/* Returns status of parser with respect to being initialized, parsing, + finished, or suspended and processing the final buffer. + XXX XML_Parse() and XML_ParseBuffer() should return XML_ParsingStatus, + XXX with XML_FINISHED_OK or XML_FINISHED_ERROR replacing XML_FINISHED +*/ +XMLPARSEAPI(void) +XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status); + +/* Creates an XML_Parser object that can parse an external general + entity; context is a '\0'-terminated string specifying the parse + context; encoding is a '\0'-terminated string giving the name of + the externally specified encoding, or NULL if there is no + externally specified encoding. The context string consists of a + sequence of tokens separated by formfeeds (\f); a token consisting + of a name specifies that the general entity of the name is open; a + token of the form prefix=uri specifies the namespace for a + particular prefix; a token of the form =uri specifies the default + namespace. This can be called at any point after the first call to + an ExternalEntityRefHandler so longer as the parser has not yet + been freed. The new parser is completely independent and may + safely be used in a separate thread. The handlers and userData are + initialized from the parser argument. Returns NULL if out of memory. + Otherwise returns a new XML_Parser object. +*/ +XMLPARSEAPI(XML_Parser) +XML_ExternalEntityParserCreate(XML_Parser parser, + const XML_Char *context, + const XML_Char *encoding); + +enum XML_ParamEntityParsing { + XML_PARAM_ENTITY_PARSING_NEVER, + XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE, + XML_PARAM_ENTITY_PARSING_ALWAYS +}; + +/* Controls parsing of parameter entities (including the external DTD + subset). If parsing of parameter entities is enabled, then + references to external parameter entities (including the external + DTD subset) will be passed to the handler set with + XML_SetExternalEntityRefHandler. The context passed will be 0. + + Unlike external general entities, external parameter entities can + only be parsed synchronously. If the external parameter entity is + to be parsed, it must be parsed during the call to the external + entity ref handler: the complete sequence of + XML_ExternalEntityParserCreate, XML_Parse/XML_ParseBuffer and + XML_ParserFree calls must be made during this call. After + XML_ExternalEntityParserCreate has been called to create the parser + for the external parameter entity (context must be 0 for this + call), it is illegal to make any calls on the old parser until + XML_ParserFree has been called on the newly created parser. + If the library has been compiled without support for parameter + entity parsing (ie without XML_DTD being defined), then + XML_SetParamEntityParsing will return 0 if parsing of parameter + entities is requested; otherwise it will return non-zero. + Note: If XML_SetParamEntityParsing is called after XML_Parse or + XML_ParseBuffer, then it has no effect and will always return 0. +*/ +XMLPARSEAPI(int) +XML_SetParamEntityParsing(XML_Parser parser, + enum XML_ParamEntityParsing parsing); + +/* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then + XML_GetErrorCode returns information about the error. +*/ +XMLPARSEAPI(enum XML_Error) +XML_GetErrorCode(XML_Parser parser); + +/* These functions return information about the current parse + location. They may be called from any callback called to report + some parse event; in this case the location is the location of the + first of the sequence of characters that generated the event. When + called from callbacks generated by declarations in the document + prologue, the location identified isn't as neatly defined, but will + be within the relevant markup. When called outside of the callback + functions, the position indicated will be just past the last parse + event (regardless of whether there was an associated callback). + + They may also be called after returning from a call to XML_Parse + or XML_ParseBuffer. If the return value is XML_STATUS_ERROR then + the location is the location of the character at which the error + was detected; otherwise the location is the location of the last + parse event, as described above. +*/ +XMLPARSEAPI(XML_Size) XML_GetCurrentLineNumber(XML_Parser parser); +XMLPARSEAPI(XML_Size) XML_GetCurrentColumnNumber(XML_Parser parser); +XMLPARSEAPI(XML_Index) XML_GetCurrentByteIndex(XML_Parser parser); + +/* Return the number of bytes in the current event. + Returns 0 if the event is in an internal entity. +*/ +XMLPARSEAPI(int) +XML_GetCurrentByteCount(XML_Parser parser); + +/* If XML_CONTEXT_BYTES is defined, returns the input buffer, sets + the integer pointed to by offset to the offset within this buffer + of the current parse position, and sets the integer pointed to by size + to the size of this buffer (the number of input bytes). Otherwise + returns a NULL pointer. Also returns a NULL pointer if a parse isn't + active. + + NOTE: The character pointer returned should not be used outside + the handler that makes the call. +*/ +XMLPARSEAPI(const char *) +XML_GetInputContext(XML_Parser parser, + int *offset, + int *size); + +/* For backwards compatibility with previous versions. */ +#define XML_GetErrorLineNumber XML_GetCurrentLineNumber +#define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber +#define XML_GetErrorByteIndex XML_GetCurrentByteIndex + +/* Frees the content model passed to the element declaration handler */ +XMLPARSEAPI(void) +XML_FreeContentModel(XML_Parser parser, XML_Content *model); + +/* Exposing the memory handling functions used in Expat */ +XMLPARSEAPI(void *) +XML_MemMalloc(XML_Parser parser, size_t size); + +XMLPARSEAPI(void *) +XML_MemRealloc(XML_Parser parser, void *ptr, size_t size); + +XMLPARSEAPI(void) +XML_MemFree(XML_Parser parser, void *ptr); + +/* Frees memory used by the parser. */ +XMLPARSEAPI(void) +XML_ParserFree(XML_Parser parser); + +/* Returns a string describing the error. */ +XMLPARSEAPI(const XML_LChar *) +XML_ErrorString(enum XML_Error code); + +/* Return a string containing the version number of this expat */ +XMLPARSEAPI(const XML_LChar *) +XML_ExpatVersion(void); + +typedef struct { + int major; + int minor; + int micro; +} XML_Expat_Version; + +/* Return an XML_Expat_Version structure containing numeric version + number information for this version of expat. +*/ +XMLPARSEAPI(XML_Expat_Version) +XML_ExpatVersionInfo(void); + +/* Added in Expat 1.95.5. */ +enum XML_FeatureEnum { + XML_FEATURE_END = 0, + XML_FEATURE_UNICODE, + XML_FEATURE_UNICODE_WCHAR_T, + XML_FEATURE_DTD, + XML_FEATURE_CONTEXT_BYTES, + XML_FEATURE_MIN_SIZE, + XML_FEATURE_SIZEOF_XML_CHAR, + XML_FEATURE_SIZEOF_XML_LCHAR, + XML_FEATURE_NS + /* Additional features must be added to the end of this enum. */ +}; + +typedef struct { + enum XML_FeatureEnum feature; + const XML_LChar *name; + long int value; +} XML_Feature; + +XMLPARSEAPI(const XML_Feature *) +XML_GetFeatureList(void); + + +/* Expat follows the GNU/Linux convention of odd number minor version for + beta/development releases and even number minor version for stable + releases. Micro is bumped with each release, and set to 0 with each + change to major or minor version. +*/ +#define XML_MAJOR_VERSION 2 +#define XML_MINOR_VERSION 0 +#define XML_MICRO_VERSION 0 + +#ifdef __cplusplus +} +#endif + +#endif /* not Expat_INCLUDED */ diff --git a/gpsbabel/msvc/Expatw/expat_external.h b/gpsbabel/msvc/Expatw/expat_external.h new file mode 100644 index 000000000..4cd16923c --- /dev/null +++ b/gpsbabel/msvc/Expatw/expat_external.h @@ -0,0 +1,115 @@ +/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd + See the file COPYING for copying permission. +*/ + +#ifndef Expat_External_INCLUDED +#define Expat_External_INCLUDED 1 + +/* External API definitions */ + +#if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__) +#define XML_USE_MSC_EXTENSIONS 1 +#endif + +/* Expat tries very hard to make the API boundary very specifically + defined. There are two macros defined to control this boundary; + each of these can be defined before including this header to + achieve some different behavior, but doing so it not recommended or + tested frequently. + + XMLCALL - The calling convention to use for all calls across the + "library boundary." This will default to cdecl, and + try really hard to tell the compiler that's what we + want. + + XMLIMPORT - Whatever magic is needed to note that a function is + to be imported from a dynamically loaded library + (.dll, .so, or .sl, depending on your platform). + + The XMLCALL macro was added in Expat 1.95.7. The only one which is + expected to be directly useful in client code is XMLCALL. + + Note that on at least some Unix versions, the Expat library must be + compiled with the cdecl calling convention as the default since + system headers may assume the cdecl convention. +*/ +#ifndef XMLCALL +#if defined(XML_USE_MSC_EXTENSIONS) +#define XMLCALL __cdecl +#elif defined(__GNUC__) && defined(__i386) +#define XMLCALL __attribute__((cdecl)) +#else +/* For any platform which uses this definition and supports more than + one calling convention, we need to extend this definition to + declare the convention used on that platform, if it's possible to + do so. + + If this is the case for your platform, please file a bug report + with information on how to identify your platform via the C + pre-processor and how to specify the same calling convention as the + platform's malloc() implementation. +*/ +#define XMLCALL +#endif +#endif /* not defined XMLCALL */ + + +#if !defined(XML_STATIC) && !defined(XMLIMPORT) +#ifndef XML_BUILDING_EXPAT +/* using Expat from an application */ + +#ifdef XML_USE_MSC_EXTENSIONS +#define XMLIMPORT __declspec(dllimport) +#endif + +#endif +#endif /* not defined XML_STATIC */ + + +/* If we didn't define it above, define it away: */ +#ifndef XMLIMPORT +#define XMLIMPORT +#endif + + +#define XMLPARSEAPI(type) XMLIMPORT type XMLCALL + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef XML_UNICODE_WCHAR_T +#define XML_UNICODE +#endif + +#ifdef XML_UNICODE /* Information is UTF-16 encoded. */ +#ifdef XML_UNICODE_WCHAR_T +typedef wchar_t XML_Char; +typedef wchar_t XML_LChar; +#else +typedef unsigned short XML_Char; +typedef char XML_LChar; +#endif /* XML_UNICODE_WCHAR_T */ +#else /* Information is UTF-8 encoded. */ +typedef char XML_Char; +typedef char XML_LChar; +#endif /* XML_UNICODE */ + +#ifdef XML_LARGE_SIZE /* Use large integers for file/stream positions. */ +#if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400 +typedef __int64 XML_Index; +typedef unsigned __int64 XML_Size; +#else +typedef long long XML_Index; +typedef unsigned long long XML_Size; +#endif +#else +typedef long XML_Index; +typedef unsigned long XML_Size; +#endif /* XML_LARGE_SIZE */ + +#ifdef __cplusplus +} +#endif + +#endif /* not Expat_External_INCLUDED */ diff --git a/gpsbabel/msvc/Expatw/libexpatw.dll b/gpsbabel/msvc/Expatw/libexpatw.dll new file mode 100644 index 0000000000000000000000000000000000000000..9aaa5a826f4bafaeef0061096e140710d5374a63 GIT binary patch literal 151552 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 lt%yz?R*WNJ{E14`M|t5!Ky + + @@ -1043,6 +1047,10 @@ RelativePath="..\gtm.c" > + + @@ -2143,10 +2151,6 @@ /> - - diff --git a/gpsbabel/msvc/Unicode.empty b/gpsbabel/msvc/Unicode.empty new file mode 100644 index 000000000..e69de29bb diff --git a/gpsbabel/msvc/config.h b/gpsbabel/msvc/config.h index 0ca922303..6c513d5a0 100644 --- a/gpsbabel/msvc/config.h +++ b/gpsbabel/msvc/config.h @@ -25,4 +25,4 @@ /* We really should figure out some way to get this from autoconf into * a file so that the MSVC build can pick it up */ -#define VERSION "1.3.0-development" +#define VERSION "1.3.1" diff --git a/gpsbabel/msvc/release.empty b/gpsbabel/msvc/release.empty new file mode 100644 index 000000000..e69de29bb -- 2.30.2